package com.sun.test;

public class RandomArray {
    public static void main(String[] args) {
        //生成一百个随机数，放入数组，然后排序输出
        //1.生成100个随机数的数组
        int[] array=createArray();
        //2.从小到大排序
//        array=orderArray(array);
        array=sortArray(array);
        //3.打印
       printArray(array);
    }

    /**
     * 生成100个随机数的方法
     * @return 生成100个随机数的数组
     */
    public static int[] createArray(){
        //创建一个长度为100的一维数组
        int[] arr=new int[100];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int)(Math.random()*100);
        }
        return arr;
    }

    /**
     * 选择排序的算法
     * @param arr 需要排序的数组
     * @return 排好序的数组
     */
    public static int[] orderArray(int[] arr){
        int temp;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j <=i; j++) {
                if(arr[i]<arr[j]){
                     temp = arr[i];
                    arr[i]=arr[j];
                    arr[j]=temp;
                }
            }
        }
        return arr;
    }


    /**
     * 冒泡排序算法：从小到大
     * @param array 要排序的数组
     * @return 排好序的数组
     */
    public static int[] sortArray(int[] array){
        int temp;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length-i-1; j++) {
                if(array[j]>array[j+1]){
                    temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
            }
        }
        return array;
    }

    /**
     * 对数组进行遍历打印的方法
     * @param arr
     */
    public static void printArray(int[] arr){
        for (int i : arr) {
            System.out.println(i);
        }
    }


    /**
     * 而且是简单的冒泡排序，应该属于交换排序，不属于经典的冒泡排序
     * @param source
     */
    public static void bubble(int[] source) {
        //无空，或者是1的情况下，不需要排序
        if (source.length==0||source.length == 1) {
            return;
        }
        //实现排序
        for (int i = 0; i < source.length; i++) {
            //简单的比较，然后交换数据......
            for (int k = i+1; k < source.length; k++) {
                if(source[i]>source[k]){
                    int temp;
                    temp=source[i];
                    source[i]=source[k];
                    source[k]=temp;
                }
            }
        }
    }

    /**
     * 经典的冒泡排序
     * @param source
     */
    public static void classicBubble(int[] source){
        if (source.length==0||source.length==1) {
            return;
        }
        //记录训话是否交换数据
        boolean flag = true;
        for (int i = 0; i < source.length&&flag; i++) {
            //记录下面循环是否有交换数据
            flag=false;
            //从后面开始，这样可以将小的元素在每次循环中都提前
            for (int j = source.length-1; j >i ; j--) {
                if (source[i]>source[i]) {
                    //交换数据
                    int temp=source[i];
                    source[i]=source[j];
                    source[j]=temp;
                    flag=true;
                }
            }
        }
    }
}
